Newt_Juvenile Class Reference

The newt juvenile class - free living but not reproductive. More...

#include <Newt.h>

Inheritance diagram for Newt_Juvenile:

Public Member Functions
	Newt_Juvenile (int a_x, int a_y, vector< unsigned > a_pond, Landscape *a_L, Newt_Population_Manager *a_NPM, unsigned a_age, bool a_reproinhib)
	Newt_Juvenile constructor. More...
	~Newt_Juvenile ()
	Newt_Juvenile destructor. More...
virtual void	ReInit (int a_x, int a_y, vector< unsigned > a_pond, Landscape *a_L, Newt_Population_Manager *a_NPM, unsigned a_age, bool a_reproinhib)
	Used to re-use an object - must be implemented in descendent classes. More...
virtual void	Step (void)
	Newt_Juvenile Step code. This is called continuously until all animals report that they are 'DONE'. More...
double	GetWeight ()
	Get method for m_weight. More...
void	SetWeight (double a_weight)
	Set method for m_weight. More...
void	InternalPesticideHandlingAndResponse ()
	For handlng of class-specific pesticide effects. More...
Public Member Functions inherited from Newt_Base
	Newt_Base (int a_x, int a_y, vector< unsigned > a_pond, Landscape *a_L, Newt_Population_Manager *a_NPM, bool a_reproinhib)
	Newt constructor. More...
void	Init (vector< unsigned > a_pond, Newt_Population_Manager *a_NPM, bool a_reproinhib)
	Intitialise object. More...
void	ReInit (int a_x, int a_y, vector< unsigned > a_pond, Landscape *a_L, Newt_Population_Manager *a_NPM, bool a_reproinhib)
	ReInit for object pool. More...
	~Newt_Base ()
	Newt destructor. More...
virtual int	WhatState ()
	Returns the state number for display purposes. More...
TTypeOfNewtState	st_Develop (void)
	Behavioural state development - does nothing in the base class. More...
TTypeOfNewtState	st_Movement (void)
	Behavioural state movement - does nothing in the base class. More...
void	st_Dying (void)
	Behavioural state dying. More...
virtual void	BeginStep (void)
	The BeginStep is the first 'part' of the timestep that an animal can behave in. It is called once per timestep. More...
virtual void	EndStep (void)
	The EndStep is the third 'part' of the timestep that an animal can behave in. It is called once per timestep. More...
unsigned	GetAge ()
	A typical interface function - this one returns the Age as an unsigned integer. More...
void	SetAge (unsigned a_age)
	A typical interface function - this one sets the Age as an unsigned integer. More...
unsigned	GetHomePond ()
	A typical interface function - this one returns the home pond reference as an unsigned integer. More...
void	SetHomePond (unsigned a_pond)
	A typical interface function - this one sets the home pond reference as an unsigned integer. More...
void	InternalPesticideHandlingAndResponse (double)
	For handlng of class-specific pesticide effects. More...
Public Member Functions inherited from TAnimal
unsigned	SupplyFarmOwnerRef ()
AnimalPosition	SupplyPosition ()
APoint	SupplyPoint ()
int	SupplyPolygonRef ()
int	Supply_m_Location_x ()
int	Supply_m_Location_y ()
virtual void	KillThis ()
virtual void	CopyMyself ()
void	SetX (int a_x)
void	SetY (int a_y)
	TAnimal (int x, int y, Landscape *L)
virtual void	ReinitialiseObject (int x, int y, Landscape *L)
	Used to re-use an object - must be implemented in descendent classes. More...
virtual void	Dying ()
void	CheckManagement (void)
void	CheckManagementXY (int x, int y)
virtual bool	OnFarmEvent (FarmToDo)
Public Member Functions inherited from TALMaSSObject
int	GetCurrentStateNo ()
	Returns the current state number. More...
void	SetCurrentStateNo (int a_num)
	Sets the current state number. More...
bool	GetStepDone ()
	Returns the step done indicator flag. More...
void	SetStepDone (bool a_bool)
	Sets the step done indicator flag. More...
virtual void	ReinitialiseObject ()
	Used to re-use an object - must be implemented in descendent classes. More...
	TALMaSSObject ()
	The constructor for TALMaSSObject. More...
virtual	~TALMaSSObject ()
	The destructor for TALMaSSObject. More...
void	OnArrayBoundsError ()
	Used for debugging only, tests basic object properties. More...

Static Public Attributes
static double	m_JuvenilePPPThreshold_Min = 0
	The minimum threshold for effect of PPP on juveniles. More...
static double	m_JuvenilePPPThreshold_EnvConc = cfg_NewtJuvenilePPPToxTrigger_EnvConc.value()
	The environmental concentration threshold for effect of PPP on juveniles. More...
static double	m_JuvenilePPPThreshold_Overspray = cfg_NewtJuvenilePPPToxTrigger_Overspray.value()
	The overspray threshold for effect of PPP on juveniles. More...
static double	m_JuvenilePPPElimRate = cfg_NewtJuvenilePPPToxEliminationRate.value()
	The daily proportion of PPP body burden that is not eliminated for juveniles. More...
static double	m_JuvenilePPPEffectProbability_EnvConc = cfg_NewtJuvenilePPPEffectProbability_EnvConc.value()
	The daily probability of effect if above m_JuvenilePPPThreshold for juveniles for environmental concentration. More...
static double	m_JuvenilePPPEffectProbability_Overspray = cfg_NewtJuvenilePPPEffectProbability_Overspray.value()
	The daily probability of effect if above m_JuvenilePPPThreshold for juveniles for overspray. More...
static double	m_JuvenileDailyWeightGain = cfg_NewtJuvenileDailyLengthGain.value()
	Used in determining daily growth. More...
static int	m_SimW = 0
	The width of the simulation map, stored for fast access. More...
static int	m_SimH = 0
	The height of the simulation map, stored for fast access. More...
static double	m_roadmortalityprob = cfg_NewtRoadMortalityProb.value()
	The probability of death when crossing a road. More...
static int	m_newtwalkspeed = cfg_NewtWalkSpeed.value()
	The max walking speed of a newt. More...
static int	m_newtwalkstepsize = cfg_NewtWalkStepsize.value()
	The size of a step when evaluating habitat during walking. More...
static double	m_goodhabitatdispersalprob = cfg_newtgoodhabitatdispersalprob.value()
	Probability of dispersal in good habitat. More...
static double	m_poorhabitatdispersalprob = cfg_newtpoorhabitatdispersalprob.value()
	Probability of dispersal in poor habitat. More...
static double	m_NewtDormancyTemperature = cfg_newtdormancytemp.value()
	Temperature in degrees that the newts become dormant. More...
static double	m_NewtDormancyHumidity = cfg_newtdormancyhumidity.value()
	Temperature in degrees that the newts become dormant. More...
Static Public Attributes inherited from Newt_Base
static double	m_EggDevelopmentDDTotal = cfg_NewtEggDevelTotal.value()
static double	m_EggDevelopmentDDParameter = cfg_NewtEggDevelDDParameter.value()
static double	m_JuvenileDevelopmentSize = cfg_NewtJuvenileDevelSize.value()
static double	m_EggMortalityChance = cfg_NewtEggMortalityChance.value()
static double	m_JuvenileMortalityChance = 0.0
static double	m_AdultMortalityChance = 0.0
static bool	m_test_pesticide_egg = cfg_Newt_Test_Pesticide_Egg.value()
	Flags to record whether we are in pesticide testing mode. More...
static bool	m_test_pesticide_larva = cfg_Newt_Test_Pesticide_Larva.value()
static bool	m_test_pesticide_terrestrial = cfg_Newt_Test_Pesticide_Terrestrial.value()

Protected Member Functions
virtual TTypeOfNewtState	st_Develop (void)
	Juvenile development state. More...
virtual TTypeOfNewtState	st_EvaluateHabitat (void)
	Juvenile evaluate habitat behaviour. More...
virtual TTypeOfNewtState	st_Disperse (void)
	Juvenile dispersal state. More...
virtual TTypeOfNewtState	st_Overwinter (void)
	Juvenile overwintering state. More...
virtual TTypeOfNewtState	st_NextStage (void)
	Juvenile maturation. More...
void	MoveTo (TTypeDirectedWalk a_directedness, int a_stepsize, int a_steps)
	Top level control of newt movement. More...
void	NewtDoWalking (int &a_vector, int a_stepsize, int a_steps, int &vx, int &vy)
	This method moves the newt through the landscape. More...
void	NewtDoWalkingCorrect (int &a_vector, int a_stepsize, int a_steps, int &vx, int &vy)
	This method moves the newt through the landscape using wrap around corrects. More...
int	NewtMoveQuality (int a_x, int a_y, TTypesOfLandscapeElement &a_tole)
	Tests the habitat quality for a square to move to. More...
Protected Member Functions inherited from TAnimal
void	CorrectWrapRound ()
	Corrects wrap around co-ordinate problems. More...

Protected Attributes
int	m_InPond
	The polyrefindex for the pond the newt is in, or -1 if not in a pond. More...
double	m_weight
unsigned	m_OurVector
	The last direction we moved in. More...
TTypesOfLandscapeElement	m_CurrentHabitat
	The current habitat type the newt is in. More...
bool	m_forcedisperse
	A flag to force dispersal from the breeding ponds. More...
Protected Attributes inherited from Newt_Base
TTypeOfNewtState	m_CurrentNewtState
	Variable to record current behavioural state. More...
unsigned	m_Age
vector< unsigned >	m_pondlist
Newt_Population_Manager *	m_OurPopulationManager
	This is a time saving pointer to the correct population manager object. More...
double	m_body_burden
	The current PPP body burden for use in pesticide testing mode. More...
bool	m_reproductiveinhibition
	A flag to indicate environmentally induced reproductive inhibition (value is inherited by descendent classes) More...
Protected Attributes inherited from TAnimal
int	m_Location_x
int	m_Location_y
Landscape *	m_OurLandscape
Protected Attributes inherited from TALMaSSObject
int	m_CurrentStateNo
	The basic state number for all objects - '-1' indicates death. More...
bool	m_StepDone
	Indicates whether the iterative step code is done for this timestep. More...

Detailed Description

The newt juvenile class - free living but not reproductive.

Constructor & Destructor Documentation

Newt_Juvenile()

Newt_Juvenile::Newt_Juvenile	(	int	a_x,
		int	a_y,
		vector< unsigned >	a_pond,
		Landscape *	a_L,
		Newt_Population_Manager *	a_NPM,
		unsigned	a_age,
		bool	a_reproinhib
	)

Newt_Juvenile constructor.

Newt_Juvenile constructor Assigns default values to specific juvenile attributes and passes the age of the juvenile from the age of the larva.

                                                                                                                                                         : Newt_Base(a_x, a_y, a_pond, a_L, a_NPM, a_reproinhib)
{
    m_weight = cfg_newtJuvenileStartSize.value();
    m_OurVector = unsigned (floor(g_rand_uni()*7.0 +0.5));
    m_forcedisperse = false;
    m_Age = a_age;
}

References cfg_newtJuvenileStartSize, g_rand_uni, Newt_Base::m_Age, m_forcedisperse, m_OurVector, m_weight, and CfgFloat::value().

~Newt_Juvenile()

Newt_Juvenile::~Newt_Juvenile

(

void

)

Newt_Juvenile destructor.

{
    ;
}

Member Function Documentation

GetWeight()

double Newt_Juvenile::GetWeight ( )

inline

Get method for m_weight.

                       {
        return m_weight;
    }

References m_weight.

InternalPesticideHandlingAndResponse()

void Newt_Juvenile::InternalPesticideHandlingAndResponse

(

)

For handlng of class-specific pesticide effects.

This method is re-implemented from Newt_Base for any class which has pesticide response behaviour. If the body burden exceeds the trigger then an effect is tested for and implemented depending on the pesticide type.

m_JuvenilePPPThreshold_Min holds the lowest trigger of any multiple effects - but we need to figure out which we have and respond accordingly there are two possibilities - a env. concentration trigger and an overspray trigger

                                                         {
    // Test against the threshold level for Juvenile to determine if an effect needs to be tested for
    if (m_body_burden > m_JuvenilePPPThreshold_Min) {
        // We are above the PPP body burden threshold, so make a test for effect
        TTypesOfPesticide tp = m_OurLandscape->SupplyPesticideType();
        switch (tp) {
        case ttop_NoPesticide:
            break;
        case ttop_ReproductiveEffects: // Reproductive effects
            if (g_rand_uni() > m_JuvenilePPPEffectProbability_EnvConc) {
                m_reproductiveinhibition = true;
            }
            break;
        case ttop_AcuteEffects: // Acute mortality
            if (g_rand_uni() > m_JuvenilePPPEffectProbability_EnvConc) {
                m_CurrentNewtState = toNewts_Die;
                KillThis();
            }
            break;
        case ttop_MultipleEffects:
            // Are we in an overspray situation?
            if (m_OurLandscape->SupplyOverspray(m_Location_x, m_Location_y)) {
                // If so, have we exceeded the overspray trigger
                if (m_body_burden > m_JuvenilePPPThreshold_Overspray) {
                    if (g_rand_uni() > m_JuvenilePPPEffectProbability_Overspray) {
                        m_CurrentNewtState = toNewts_Die;
                        KillThis();
                    }
                }
            }
            // Not overspray so test the env conc trigger
            else if (m_body_burden > m_JuvenilePPPThreshold_EnvConc) {
                if (g_rand_uni() > m_JuvenilePPPEffectProbability_EnvConc) {
                    m_CurrentNewtState = toNewts_Die;
                    KillThis();
                }
            }
            break;
        default:
            g_msg->Warn("Unknown pesticide type used in Newt_Juvenile::InternalPesticideHandlingAndResponse() pesticide code ", int(tp));
            exit(47);
        }
    }
}

References g_msg, g_rand_uni, TAnimal::KillThis(), Newt_Base::m_body_burden, Newt_Base::m_CurrentNewtState, m_JuvenilePPPEffectProbability_EnvConc, m_JuvenilePPPEffectProbability_Overspray, m_JuvenilePPPThreshold_EnvConc, m_JuvenilePPPThreshold_Min, m_JuvenilePPPThreshold_Overspray, TAnimal::m_Location_x, TAnimal::m_Location_y, TAnimal::m_OurLandscape, Newt_Base::m_reproductiveinhibition, Landscape::SupplyOverspray(), Landscape::SupplyPesticideType(), toNewts_Die, ttop_AcuteEffects, ttop_MultipleEffects, ttop_NoPesticide, ttop_ReproductiveEffects, and MapErrorMsg::Warn().

Referenced by st_Develop().

MoveTo()

void Newt_Juvenile::MoveTo ( TTypeDirectedWalk  a_directedness, int  a_stepsize, int  a_steps  )

protected

Top level control of newt movement.

This is part of the movement method for all newts. It checks whether there is any need to consider wrap-around and then calls movement the appropriate number of times passing a_vector, which is used to determine the direction (if any), and a_directedness, which determines the degree of directed movement:

• directedwalk_totally = 1,
• directedwalk_high = 3,
• directedwalk_medium = 5,
• directedwalk_low = 7,
• directedwalk_random = 8

                                                                                         {
    int direction = int( g_rand_uni()*a_directedness + m_OurVector ) & 0x07;
    int MaxPossDistance = a_stepsize*a_steps;
    if ((m_Location_x - MaxPossDistance < 0) || (m_Location_x + MaxPossDistance >= m_SimW) || (m_Location_y - MaxPossDistance < 0) || (m_Location_y + MaxPossDistance >= m_SimH)) {
        // Need correct coords
        // Make sure that the coords can't become -ve
        int vx = m_Location_x + m_SimW;
        int vy = m_Location_y + m_SimH;
        NewtDoWalkingCorrect( direction, a_stepsize, a_steps, vx, vy );
        m_Location_x = vx % m_SimW;
        m_Location_y = vy % m_SimH;
    }
    else {
        // Don't need correct coords
        int vx = m_Location_x;
        int vy = m_Location_y;
        NewtDoWalking( direction, a_stepsize, a_steps, vx, vy );
        // alter the voles location (& correct coords)
        m_Location_x = vx;
        m_Location_y = vy;
    }
}

References g_rand_uni, TAnimal::m_Location_x, TAnimal::m_Location_y, m_OurVector, m_SimH, m_SimW, NewtDoWalking(), and NewtDoWalkingCorrect().

Referenced by st_Disperse(), Newt_Adult::st_Disperse(), and Newt_Adult::st_Migrate().

NewtDoWalking()

void Newt_Juvenile::NewtDoWalking ( int &  a_vector, int  a_stepsize, int  a_steps, int &  vx, int &  vy  )

protected

This method moves the newt through the landscape.

This method does the actual stepping - there is no look ahead here, so steps are taken one at a time based on the habitat type and vector given. This is a very time critical method. The relative locations of each direction compared to the present x,y, are stored in StepsX and StepsY. These locations use the step size. For the newt we only care whether they can walk there, and if we are on a road. So it will rarely necessary to test more than a single location, hence this implementation differs from e.g. vole, that makes decisions based on habitat choice. For the newt this is more based on whether to move and how much than active choices.

Parameters

a_vector	[in] The initial direction to move in.
a_steps	[in] The number of steps to take
a_stepsize	[in] The size of each step in m - this effectively allows the newt to skip over testing each and every step
vx	[in][out] The starting x-coordinate for the movement
vy	[in][out] The starting y-coordinate for the movement

If a newt steps onto a road then the chance of mortality is dependent on an external parameter stored in m_roadmortalityprob This value is multiplied by the return value of NewtMoveQuality which will increase with the size of the road (or could be linked to traffic information in the future).

                                                                                                {
    int StepsX;
    int StepsY;
    int testquality;
    TTypesOfLandscapeElement tole;
 
    StepsX = Vector_x[ a_vector ] * a_stepsize;
    StepsY = Vector_y[ a_vector ] * a_stepsize;
    for (int i = 0; i < a_steps; i++) {
        // test the squares at Vector, Vector+1+2, Vector-1-2
        // They have either a quality or are inaccessible (water,buildings)
        // if can go to one of these squares then pick the best one
        // if all or some are equal then take a random pick.
        // if all are 'bad' then add or subtract one from vector and try again
        testquality = NewtMoveQuality( (vx + StepsX), (vy + StepsY), tole );
        if (testquality == -1) {
            // can't go anywhere so change the vector
            if (random( 2 )) ++a_vector; else (--a_vector);
            a_vector &= 0x07;
        }
        else {
            if (testquality > 0) {
                // On a dangerous habitat. take a mortality test
                if (g_rand_uni() < m_roadmortalityprob * testquality) {
                    m_CurrentNewtState = toNewts_Die;
                    return;
                }
            }
            // change co-ordinates
            vx += StepsX;
            vy += StepsY;
            m_CurrentHabitat = tole;
        }
    }
}

References g_rand_uni, m_CurrentHabitat, Newt_Base::m_CurrentNewtState, m_roadmortalityprob, NewtMoveQuality(), random(), toNewts_Die, Vector_x, and Vector_y.

Referenced by MoveTo().

NewtDoWalkingCorrect()

void Newt_Juvenile::NewtDoWalkingCorrect ( int &  a_vector, int  a_stepsize, int  a_steps, int &  vx, int &  vy  )

protected

This method moves the newt through the landscape using wrap around corrects.

This method does the actual stepping. It is identical to NewtDoWalking except it corrects for warparound issues. There is no look ahead here, so steps are taken one at a time based on the habitat type and vector given. This is a very time critical method. The relative locations of each direction compared to the present x,y, are stored in StepsX and StepsY. These locations use the step size. For the newt we only care whether they can walk there, and if we are on a road. So it will rarely necessary to test more than a single location, hence this implementation differs from e.g. vole, that makes decisions based on habitat choice. For the newt this is more based on whether to move and how much than active choices.

Parameters

a_vector	[in] The initial direction to move in.
a_steps	[in] The number of steps to take
a_stepsize	[in] The size of each step in m - this effectively allows the newt to skip over testing each and every step
vx	[in][out] The starting x-coordinate for the movement
vy	[in][out] The starting y-coordinate for the movement

If a newt steps onto a road then the chance of mortality is dependent on an external parameter stored in m_roadmortalityprob This value is multiplied by the return value of NewtMoveQuality which will increase with the size of the road (or could be linked to traffic information in the future).

                                                                                                       {
    int StepsX;
    int StepsY;
    int testquality;
    TTypesOfLandscapeElement tole;
    StepsX = Vector_x[ a_vector ] * a_stepsize + m_SimW;
    StepsY = Vector_x[ a_vector ] * a_stepsize + m_SimH;
    for (int i = 0; i < a_steps; i++) {
        // test the squares at Vector, Vector+1+2, Vector-1-2
        // They have either a quality or are inaccessible (water,buildings)
        // if can go to one of these squares then pick the best one
        // if all or some are equal then take a random pick.
        // if all are 'bad' then add or subtract one from vector and try again
        testquality = NewtMoveQuality( (vx + StepsX) % m_SimW, (vy + StepsY) % m_SimH, tole );
        if (testquality == -1) {
            // can't go anywhere so change the vector
            if (random( 2 )) ++a_vector; else (--a_vector);
            a_vector &= 0x07;
        }
        else {
            if (testquality > 0) {
                // On a dangerous habitat. take a mortality test
                if (g_rand_uni() < m_roadmortalityprob) {
                    m_CurrentNewtState = toNewts_Die;
                    return;
                }
            }
            // change co-ordinates and save the current habitat type we are in
            vx += (m_SimW + StepsX) % m_SimW;
            vy += (m_SimH + StepsY) % m_SimH;
            m_CurrentHabitat = tole;
        }
    }
}

References g_rand_uni, m_CurrentHabitat, Newt_Base::m_CurrentNewtState, m_roadmortalityprob, m_SimH, m_SimW, NewtMoveQuality(), random(), toNewts_Die, and Vector_x.

Referenced by MoveTo().

NewtMoveQuality()

int Newt_Juvenile::NewtMoveQuality ( int  a_x, int  a_y, TTypesOfLandscapeElement &  a_tole  )

protected

Tests the habitat quality for a square to move to.

This is where the movement onto a habitat is evaluted and either returns a yes can move here, a n cannot move hereo, or a yes with a mortality chance. If the habitat is breeding habitat this is recorded otherwise

                                                                                       {
    unsigned poly_index = m_OurLandscape->SupplyPolyRefIndex( a_x, a_y );
    a_tole = m_OurLandscape->SupplyElementTypeFromVector( poly_index );
    switch (a_tole) {
        case tole_UrbanNoVeg:
        case tole_Building: // 5
        case tole_River: // 96
        case tole_Saltmarsh: // 95
        case tole_Saltwater: // 80
        case tole_Coast: // 100
            return -1; // Cannot move here
        case tole_SmallRoad: // 122
            m_InPond = -1;
            return 1; // Road mortality x1
        case tole_LargeRoad: // 121
            m_InPond = -1;
            return 2; // Road mortality x2
        case tole_Pond:
        {
            m_InPond = poly_index;
            bool found = false;
            for (unsigned p = 0; p < m_pondlist.size(); p++)
                if (m_pondlist[ p ] == poly_index) found = true;
            if (!found) m_pondlist.push_back( poly_index );
        }
        return 0;
        default:
            m_InPond = -1;
            return 0; // Can move here
    }
}

References m_InPond, TAnimal::m_OurLandscape, Newt_Base::m_pondlist, Landscape::SupplyElementTypeFromVector(), Landscape::SupplyPolyRefIndex(), tole_Building, tole_Coast, tole_LargeRoad, tole_Pond, tole_River, tole_Saltmarsh, tole_Saltwater, tole_SmallRoad, and tole_UrbanNoVeg.

Referenced by NewtDoWalking(), and NewtDoWalkingCorrect().

ReInit()

void Newt_Juvenile::ReInit ( int  a_x, int  a_y, vector< unsigned >  a_pond, Landscape *  a_L, Newt_Population_Manager *  a_NPM, unsigned  a_age, bool  a_reproinhib  )

virtual

Used to re-use an object - must be implemented in descendent classes.

Reimplemented in Newt_Female, Newt_Male, and Newt_Adult.

                                                                                                                                                       {
    Newt_Base::ReInit(a_x, a_y, a_pond, a_L, a_NPM, a_reproinhib);
    m_weight = cfg_newtJuvenileStartSize.value();
    m_OurVector = unsigned(floor(g_rand_uni()*7.0 + 0.5));
    m_forcedisperse = false;
    m_Age = a_age;
}

References cfg_newtJuvenileStartSize, g_rand_uni, Newt_Base::m_Age, m_forcedisperse, m_OurVector, m_weight, Newt_Base::ReInit(), and CfgFloat::value().

Referenced by Newt_Population_Manager::CreateObjects(), and Newt_Adult::ReInit().

SetWeight()

void Newt_Juvenile::SetWeight ( double  a_weight )

inline

Set method for m_weight.

                                      {
        m_weight = a_weight;
    }

References m_weight.

Referenced by Newt_Population_Manager::CreateObjects().

st_Develop()

TTypeOfNewtState Newt_Juvenile::st_Develop ( void  )

protectedvirtual

Juvenile development state.

First determines whether the juvenile sucumbs to daily mortality, if so return toNewts_Die state.
Next if there is the need to test for pesticide effects then the body-burden is adjusted for yesterdays elimination, then pesticide at this location is determined and any intake stored. If the body-burden is greater than the threshold for effects, then InternalPesticideHandlingAndResponse is called and the impacts determined. If the juvenile survives:

• The age is incremented
• Length is added as a daily increment based on an input parameter
• If the total length exceeds the parameter value held in m_JuvenileDevelopmentSize, the juvenile should mature and the state toNewts_NextStage is returned
• the behavioural state st_EvaluateHabitat is called following st_Develop, which leads to either a dispersal state or return to this state on the next day.
• If the newt is in pond then dispersal if forced.

Reimplemented in Newt_Female, Newt_Male, and Newt_Adult.

                                                 {
    if (g_rand_uni() < m_JuvenileMortalityChance) return toNewts_Die;
    // We need to test pesticide if m_test_pesticide is set
    if (m_test_pesticide_terrestrial) {
        // Eliminate some/all of yesterdays body burden of PPP by multiplying by 1-the daily elimination rate
        m_body_burden *= m_JuvenilePPPElimRate;
        // Pick up the pesticide to add to the body burden
        m_body_burden += m_OurLandscape->SupplyPesticide(m_Location_x, m_Location_y, ppp_1);
        // Test against the threshold level for adult to determine if an effect needs to be tested for
        InternalPesticideHandlingAndResponse();
        if (m_CurrentNewtState == toNewts_Die) return toNewts_Die;
    }
    m_Age++; // we get older but not heavier if cold
    if (m_OurLandscape->SupplyTempPeriod( g_date->Date(), 5 ) < m_NewtDormancyTemperature) {
        return toNewts_Overwinter;
    }   
    m_weight += m_JuvenileDailyWeightGain;
    if (m_weight > m_JuvenileDevelopmentSize) return toNewts_NextStage;
    if (m_InPond) m_forcedisperse = true; 
    return toNewts_EvaluateLocation;
}

References Calendar::Date(), g_date, g_rand_uni, InternalPesticideHandlingAndResponse(), Newt_Base::m_Age, Newt_Base::m_body_burden, Newt_Base::m_CurrentNewtState, m_forcedisperse, m_InPond, m_JuvenileDailyWeightGain, Newt_Base::m_JuvenileDevelopmentSize, Newt_Base::m_JuvenileMortalityChance, m_JuvenilePPPElimRate, TAnimal::m_Location_x, TAnimal::m_Location_y, m_NewtDormancyTemperature, TAnimal::m_OurLandscape, Newt_Base::m_test_pesticide_terrestrial, m_weight, ppp_1, Landscape::SupplyPesticide(), Landscape::SupplyTempPeriod(), toNewts_Die, toNewts_EvaluateLocation, toNewts_NextStage, and toNewts_Overwinter.

Referenced by Step().

st_Disperse()

TTypeOfNewtState Newt_Juvenile::st_Disperse ( void  )

protectedvirtual

Juvenile dispersal state.

The newt can only move around when the humidity is high. Here we assume this is related to the rainfall and temperature of the preceding days. If the humidity is high enough then the newt moves otherwise it stays where it is and returns toNewts_Develop.
The newt moves around using a random walk. At each step it evaluates if the habitat is walks onto is legal (if not it does not move), and if a pond it remembers this. The new pond is added to the m_pondlist vector.
The rate of the random walk is set by a input parameter stored in the static attribute m_newtwalkspeed, and is a uniform random distribution between 0 and this value. During the dispersal roads have associated mortality risks. These are flagged and probability tests taken.
If killed in dispersal, the current state will be changed to die by MoveTo->NewtDoWalking, so if this has been altered from toNewts_Dispersal then return the new state, otherwise returns toNewts_Develop.

Reimplemented in Newt_Adult.

                                                  {
    TTypeDirectedWalk  directedness = directedwalk_random;
    if (m_forcedisperse) directedness = directedwalk_high;
    double temp = m_OurLandscape->SupplyTempPeriod(g_date->Date(), 5);
    double humidity = m_OurLandscape->SupplyHumidity();
    if ((temp > m_NewtDormancyTemperature) && (humidity > m_NewtDormancyHumidity))
    {
        MoveTo(directedness, m_newtwalkstepsize, int(m_newtwalkspeed*g_rand_uni()));
        if (m_CurrentNewtState == toNewts_Die) return toNewts_Die;
    }
    return toNewts_Develop;
}

References Calendar::Date(), directedwalk_high, directedwalk_random, g_date, g_rand_uni, Newt_Base::m_CurrentNewtState, m_forcedisperse, m_NewtDormancyHumidity, m_NewtDormancyTemperature, m_newtwalkspeed, m_newtwalkstepsize, TAnimal::m_OurLandscape, MoveTo(), Landscape::SupplyHumidity(), Landscape::SupplyTempPeriod(), toNewts_Develop, and toNewts_Die.

Referenced by Step().

st_EvaluateHabitat()

TTypeOfNewtState Newt_Juvenile::st_EvaluateHabitat ( void  )

protectedvirtual

Juvenile evaluate habitat behaviour.

Assesses where it is stood. If the habitat is good it sets the dispersal chance to m_goodhabitatdispersalprob otherwise to m_poorhabitatdispersalprob It then takes a prbobability test to determine whether to dispserse. Will return disperse or develop states depending on the result of the test.

Reimplemented in Newt_Female, Newt_Male, and Newt_Adult.

                                                       {
    TTypesOfLandscapeElement tole = m_OurLandscape->SupplyElementType(m_Location_x, m_Location_y);
    double chance = m_goodhabitatdispersalprob;
    if (tole == tole_Pond)
    {
        m_forcedisperse = true;
        return toNewts_Dispersal;
    }
    else
    {
        m_forcedisperse = false;
        switch (tole) {
        case tole_Marsh:
        case tole_NaturalGrassWet:
            break;
        default:
            chance = m_poorhabitatdispersalprob;
        }
        if (g_rand_uni() < chance) return toNewts_Dispersal;
    }
    return toNewts_Develop;
}

References g_rand_uni, m_forcedisperse, m_goodhabitatdispersalprob, TAnimal::m_Location_x, TAnimal::m_Location_y, TAnimal::m_OurLandscape, m_poorhabitatdispersalprob, Landscape::SupplyElementType(), tole_Marsh, tole_NaturalGrassWet, tole_Pond, toNewts_Develop, and toNewts_Dispersal.

Referenced by Newt_Adult::st_EvaluateHabitat(), Newt_Female::st_EvaluateHabitat(), and Step().

st_NextStage()

TTypeOfNewtState Newt_Juvenile::st_NextStage ( void  )

protectedvirtual

Juvenile maturation.

Creates a new Newt_Male or Newt_Female object and passes the data from the young to it, then signals young object removal.

                                                   {
    struct_Newt sN;
    sN.NPM = m_OurPopulationManager;
    sN.L = m_OurLandscape;
    sN.age = m_Age;
    sN.x = m_Location_x;
    sN.y = m_Location_y;
    sN.pondrefs = m_pondlist;
    sN.weight = m_weight;
    sN.reproinhib = m_reproductiveinhibition;
    if (g_rand_uni()<0.5) m_OurPopulationManager->CreateObjects( tton_Male, NULL, &sN, 1 ); 
    else m_OurPopulationManager->CreateObjects( tton_Female, NULL, &sN, 1 ); 
    m_CurrentStateNo = -1;
    m_StepDone = true;
    return toNewts_Remove; // Not necessary, but for neatness
}

References struct_Newt::age, Newt_Population_Manager::CreateObjects(), g_rand_uni, struct_Newt::L, Newt_Base::m_Age, TALMaSSObject::m_CurrentStateNo, TAnimal::m_Location_x, TAnimal::m_Location_y, TAnimal::m_OurLandscape, Newt_Base::m_OurPopulationManager, Newt_Base::m_pondlist, Newt_Base::m_reproductiveinhibition, TALMaSSObject::m_StepDone, m_weight, struct_Newt::NPM, struct_Newt::pondrefs, struct_Newt::reproinhib, toNewts_Remove, tton_Female, tton_Male, struct_Newt::weight, struct_Newt::x, and struct_Newt::y.

Referenced by Step().

st_Overwinter()

TTypeOfNewtState Newt_Juvenile::st_Overwinter ( void  )

protectedvirtual

Juvenile overwintering state.

Reimplemented in Newt_Adult.

                                                    {
    if (g_rand_uni() < m_JuvenileMortalityChance) return toNewts_Die;
    if (m_OurLandscape->SupplyTempPeriod( g_date->Date(), 5 )> m_NewtDormancyTemperature) {
        return toNewts_Develop;
    }
    return toNewts_Overwinter;
}

References Calendar::Date(), g_date, g_rand_uni, Newt_Base::m_JuvenileMortalityChance, m_NewtDormancyTemperature, TAnimal::m_OurLandscape, Landscape::SupplyTempPeriod(), toNewts_Develop, toNewts_Die, and toNewts_Overwinter.

Referenced by Step().

Step()

void Newt_Juvenile::Step ( void  )

virtual

Newt_Juvenile Step code. This is called continuously until all animals report that they are 'DONE'.

Reimplemented from Newt_Base.

Reimplemented in Newt_Female, and Newt_Male.

                             {
    if (m_StepDone || m_CurrentStateNo == -1) return;
    switch (m_CurrentNewtState) {
        case toNewts_InitialState: // Initial state always starts with develop
            m_CurrentNewtState = toNewts_Develop;
            break;
        case toNewts_Develop:
            m_CurrentNewtState = st_Develop(); // Will return evaluate location, overwinter, next stage or die
            break;
        case toNewts_Dispersal:
            m_CurrentNewtState = st_Disperse(); 
            break;
        case toNewts_EvaluateLocation:
            m_CurrentNewtState = st_EvaluateHabitat();
            m_StepDone = true;
            break;
        case toNewts_Overwinter:
            m_CurrentNewtState = st_Overwinter();
            m_StepDone = true;
            break;
        case toNewts_NextStage:
            st_NextStage();
            break;
        case toNewts_Die:
            st_Dying(); // No return
            m_StepDone = true;
            break;
        case toNewts_Remove:
            m_CurrentStateNo = -1;
            m_StepDone = true;
            break;
        default:
            m_OurLandscape->Warn( "Newt_Juvenile::Step()", " unknown state" );
            exit( 1 );
    }
}

References Newt_Base::m_CurrentNewtState, TALMaSSObject::m_CurrentStateNo, TAnimal::m_OurLandscape, TALMaSSObject::m_StepDone, st_Develop(), st_Disperse(), Newt_Base::st_Dying(), st_EvaluateHabitat(), st_NextStage(), st_Overwinter(), toNewts_Develop, toNewts_Die, toNewts_Dispersal, toNewts_EvaluateLocation, toNewts_InitialState, toNewts_NextStage, toNewts_Overwinter, toNewts_Remove, and Landscape::Warn().

Member Data Documentation

m_CurrentHabitat

TTypesOfLandscapeElement Newt_Juvenile::m_CurrentHabitat

protected

The current habitat type the newt is in.

Referenced by NewtDoWalking(), NewtDoWalkingCorrect(), and Newt_Adult::st_Migrate().

m_forcedisperse

bool Newt_Juvenile::m_forcedisperse

protected

A flag to force dispersal from the breeding ponds.

Referenced by Newt_Juvenile(), ReInit(), st_Develop(), st_Disperse(), Newt_Adult::st_Disperse(), st_EvaluateHabitat(), Newt_Adult::st_EvaluateHabitat(), and Newt_Female::st_EvaluateHabitat().

m_goodhabitatdispersalprob

double Newt_Juvenile::m_goodhabitatdispersalprob = cfg_newtgoodhabitatdispersalprob.value()

static

Probability of dispersal in good habitat.

Referenced by Newt_Population_Manager::Newt_Population_Manager(), and st_EvaluateHabitat().

m_InPond

int Newt_Juvenile::m_InPond

protected

The polyrefindex for the pond the newt is in, or -1 if not in a pond.

Referenced by Newt_Male::BeginStep(), Newt_Adult::GetInPond(), Newt_Adult::Init(), NewtMoveQuality(), Newt_Adult::SetInPond(), Newt_Female::st_Breed(), st_Develop(), Newt_Adult::st_EvaluateHabitat(), Newt_Female::st_EvaluateHabitat(), and Newt_Adult::st_Migrate().

m_JuvenileDailyWeightGain

double Newt_Juvenile::m_JuvenileDailyWeightGain = cfg_NewtJuvenileDailyLengthGain.value()

static

Used in determining daily growth.

Referenced by Newt_Population_Manager::Newt_Population_Manager(), and st_Develop().

m_JuvenilePPPEffectProbability_EnvConc

double Newt_Juvenile::m_JuvenilePPPEffectProbability_EnvConc = cfg_NewtJuvenilePPPEffectProbability_EnvConc.value()

static

The daily probability of effect if above m_JuvenilePPPThreshold for juveniles for environmental concentration.

Referenced by InternalPesticideHandlingAndResponse(), and Newt_Population_Manager::Newt_Population_Manager().

m_JuvenilePPPEffectProbability_Overspray

double Newt_Juvenile::m_JuvenilePPPEffectProbability_Overspray = cfg_NewtJuvenilePPPEffectProbability_Overspray.value()

static

The daily probability of effect if above m_JuvenilePPPThreshold for juveniles for overspray.

Referenced by InternalPesticideHandlingAndResponse(), and Newt_Population_Manager::Newt_Population_Manager().

m_JuvenilePPPElimRate

double Newt_Juvenile::m_JuvenilePPPElimRate = cfg_NewtJuvenilePPPToxEliminationRate.value()

static

The daily proportion of PPP body burden that is not eliminated for juveniles.

Referenced by Newt_Population_Manager::Newt_Population_Manager(), and st_Develop().

m_JuvenilePPPThreshold_EnvConc

double Newt_Juvenile::m_JuvenilePPPThreshold_EnvConc = cfg_NewtJuvenilePPPToxTrigger_EnvConc.value()

static

The environmental concentration threshold for effect of PPP on juveniles.

Referenced by InternalPesticideHandlingAndResponse(), and Newt_Population_Manager::Newt_Population_Manager().

m_JuvenilePPPThreshold_Min

double Newt_Juvenile::m_JuvenilePPPThreshold_Min = 0

static

The minimum threshold for effect of PPP on juveniles.

Class Newt_Juvenile represents the juvenile stage of the newt.
In addition to inherited attributes from Newt_Larva, each juvenile has:

• m_weight which is the weight of the newt in g
• m_SimW - the width of the simulation map, a static variable used for speed
• m_SimH - the height of the simulation map, a static variable used for speed
• m_CurrentHabitat - the current habitat type the newt is located in
• m_InPond is the polyrefindex for the pond the newt is in, or -1 if not in a pond
• m_SimW The width of the simulation map, stored for fast access
• m_SimH The height of the simulation map, stored for fast access
• m_OurVector The last direction the newt moved in

Other new attributes are included here for efficient storage of input parameters

• m_JuvenileDailyWeightGain Used in determining daily growth, this is the daily increment.
• m_roadmortalityprob The probability of death when crossing a road, this is per movement (1 x m_newtwalkspeed).
• m_newtwalkspeed The max walking speed of a newt per movement (1 day)
• m_newtwalkstepsize The size of a step when evaluating habitat during walking - used to speed up movement if necessary, default is 1m
• m_goodhabitatdispersalprob Probability of dispersal in good habitat
• m_poorhabitatdispersalprob Probability of dispersal in poor habitat
• m_NewtDormancyTemperature Temperature in degrees that the newts become dormant and stop moving or breeding (summed over previous 5 days) Default value is 22.5 based on Langton et al (2001) who state 4-5 degrees.

New behaviours are introduced here:

• st_Disperse this moves the newts out of and away from the pond
• st_Overwinter this is where the newt enters a semi-torpid state over winter (ie does not move).

Referenced by InternalPesticideHandlingAndResponse(), and Newt_Population_Manager::Newt_Population_Manager().

m_JuvenilePPPThreshold_Overspray

double Newt_Juvenile::m_JuvenilePPPThreshold_Overspray = cfg_NewtJuvenilePPPToxTrigger_Overspray.value()

static

The overspray threshold for effect of PPP on juveniles.

Referenced by InternalPesticideHandlingAndResponse(), and Newt_Population_Manager::Newt_Population_Manager().

m_NewtDormancyHumidity

double Newt_Juvenile::m_NewtDormancyHumidity = cfg_newtdormancyhumidity.value()

static

Temperature in degrees that the newts become dormant.

Referenced by Newt_Population_Manager::Newt_Population_Manager(), st_Disperse(), and Newt_Adult::st_Disperse().

m_NewtDormancyTemperature

double Newt_Juvenile::m_NewtDormancyTemperature = cfg_newtdormancytemp.value()

static

Temperature in degrees that the newts become dormant.

Referenced by Newt_Population_Manager::Newt_Population_Manager(), st_Develop(), Newt_Adult::st_Develop(), st_Disperse(), Newt_Adult::st_Disperse(), st_Overwinter(), and Newt_Adult::st_Overwinter().

m_newtwalkspeed

int Newt_Juvenile::m_newtwalkspeed = cfg_NewtWalkSpeed.value()

static

The max walking speed of a newt.

Referenced by Newt_Population_Manager::Newt_Population_Manager(), st_Disperse(), and Newt_Adult::st_Migrate().

m_newtwalkstepsize

int Newt_Juvenile::m_newtwalkstepsize = cfg_NewtWalkStepsize.value()

static

The size of a step when evaluating habitat during walking.

Referenced by Newt_Population_Manager::Newt_Population_Manager(), st_Disperse(), Newt_Adult::st_Disperse(), and Newt_Adult::st_Migrate().

m_OurVector

unsigned Newt_Juvenile::m_OurVector

protected

The last direction we moved in.

Referenced by Newt_Adult::CalcMovementVector(), MoveTo(), Newt_Juvenile(), ReInit(), and Newt_Adult::st_Migrate().

m_poorhabitatdispersalprob

double Newt_Juvenile::m_poorhabitatdispersalprob = cfg_newtpoorhabitatdispersalprob.value()

static

Probability of dispersal in poor habitat.

Referenced by Newt_Population_Manager::Newt_Population_Manager(), and st_EvaluateHabitat().

m_roadmortalityprob

double Newt_Juvenile::m_roadmortalityprob = cfg_NewtRoadMortalityProb.value()

static

The probability of death when crossing a road.

Referenced by Newt_Population_Manager::Newt_Population_Manager(), NewtDoWalking(), and NewtDoWalkingCorrect().

m_SimH

int Newt_Juvenile::m_SimH = 0

static

The height of the simulation map, stored for fast access.

Referenced by MoveTo(), Newt_Population_Manager::Newt_Population_Manager(), NewtDoWalkingCorrect(), and Newt_Adult::st_Migrate().

m_SimW

int Newt_Juvenile::m_SimW = 0

static

The width of the simulation map, stored for fast access.

Referenced by MoveTo(), Newt_Population_Manager::Newt_Population_Manager(), NewtDoWalkingCorrect(), and Newt_Adult::st_Migrate().

m_weight

double Newt_Juvenile::m_weight

protected

/brief The weight of the newt in grammes

Referenced by GetWeight(), Newt_Juvenile(), ReInit(), SetWeight(), st_Develop(), and st_NextStage().

---

The documentation for this class was generated from the following files:

• /builds/a1mass/almass_stable_oddox/Newt/Newt.h
• /builds/a1mass/almass_stable_oddox/Newt/Newt.cpp
• /builds/a1mass/almass_stable_oddox/Newt/Newt_Population_Manager.cpp